package com.itfenghuang.day11;

import java.io.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


public class A03_复习 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, ExecutionException, InterruptedException {
//        method();

        //多线程
        //  1. 同时执行多个程序 2. 多线程需要硬件支持
        //  并行:  同一时刻,多个指令在多个 cpu 上同时执行
        //  并发:  同一时刻,多个指令在单个 cpu 上交替执行
        //  进程:  正在进行的程序
        //  线程:  进程中一条执行路劲
        //  单线程; 一个进程只有一条执行路径,则称为单线程程序
        //  多线程: 一个进程中有多条执行路劲,则称为多线程程序

        //实现多线程的方式之一
        // 继承Thread   java中的线程类
        // 1. 自定义类 继承 Thread
        // 2. 自定义类中重写 run() 方法         run() 方法:  就是当前线程要执行的任务
        // 3. 创建自定义类对象,在测试类中
        Abc abc = new Abc();
        // 4. 启动线程      start() 方法:  使此线程开启开始执行,jvm自动调用run() 方法
        abc.start();

        //实现多线程的方式之二
        // 实现 Runnable接口
        // 1.自定义一个类 实现 Runnable接口
        // 2. 自定义类中重写 run() 方法
        // 3. 创建自定义类对象
        Bcd bcd = new Bcd();
        // 4,.创建 Thread 对象,将自定义对象通过构造方法传进来
        Thread thread = new Thread(bcd);
        // 5.开启线程
        thread.start();

        //实现多线程的方式之三
        // 实现Callable 接口
        // 1. 自定义类实现 Callable 接口 ,重写 call() 方法
        // 2. 创建自定义类对象
        Cdf cdf = new Cdf();
        // 3. 创建 Future 的实现类 FutureTask 对象,将自定义类通过构造方法传递过去
        FutureTask<Object> task = new FutureTask<>(cdf);
        // 4. 创建 Thread 类, 将将futureTask对象通过构造方法传递过去
        Thread thread1 = new Thread(task);
        // 5. 开启线程
        thread1.start();
        //使用futuretask对象获取线程的返回值
        System.out.println(task.get());






    }

    private static void method() throws IOException, ClassNotFoundException {
        // 1对象操作流

        //创建对象操作输出流/对象序列化流  可以将对象从内存中写到本地文件中
        //对象 implements  Serializable
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\it\\a.txt"));
        Uuu uuu = new Uuu("爆爆","1234");
        oos.writeObject(uuu);
        oos.close();

        //使用反序列化读入对象
        //某个属性不想序列化  该属性前加关键字 transient  显示为null
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\it\\a.txt"));
        System.out.println(ois.readObject());
        ois.close();

        //用对象序列化流序列化一个对象后,假如修改了对象所属的类,再进行反序列化操作会出现问题
        // 异常  InvalidClassException
        //解决问题  对象类中天健public static final long serialVersionUID = 1L;


    }
}


class Uuu implements Serializable{
    private String id;
    private transient String password;
    private String name;
    private static final long serialVersionUID=1L;

    @Override
    public String toString() {
        return "Uuu{" +
                "id='" + id + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Uuu() {
    }

    public Uuu(String id, String password) {
        this.id = id;
        this.password = password;
    }
}
class Abc extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("飞飞飞飞飞="+i);
        }
    }
}
class Bcd implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("七七七七七七七"+i);
        }
    }
}
class Cdf implements Callable<Object>{

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 1000; i++) {
            System.out.println("一一一一一一一一一"+i);
        }
        return "起飞咯";
    }
}